/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.h.zapt

#pragma once

#include <app/data-model/DecodableList.h>
#include <app/data-model/Encode.h>
#include <app/data-model/List.h>
#include <app/data-model/NullObject.h>
#include <app/data-model/Nullable.h>
#include <lib/core/DataModelTypes.h>
#include <lib/core/Optional.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/DoorLock/ClusterId.h>
#include <clusters/DoorLock/CommandIds.h>
#include <clusters/DoorLock/Enums.h>
#include <clusters/DoorLock/Structs.h>

#include <cstdint>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace DoorLock
		{
			namespace Commands
			{
				// Forward-declarations so we can reference these later.

				namespace LockDoor
				{
					struct Type;
					struct DecodableType;
				} // namespace LockDoor

				namespace UnlockDoor
				{
					struct Type;
					struct DecodableType;
				} // namespace UnlockDoor

				namespace UnlockWithTimeout
				{
					struct Type;
					struct DecodableType;
				} // namespace UnlockWithTimeout

				namespace SetWeekDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace SetWeekDaySchedule

				namespace GetWeekDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace GetWeekDaySchedule

				namespace GetWeekDayScheduleResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetWeekDayScheduleResponse

				namespace ClearWeekDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearWeekDaySchedule

				namespace SetYearDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace SetYearDaySchedule

				namespace GetYearDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace GetYearDaySchedule

				namespace GetYearDayScheduleResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetYearDayScheduleResponse

				namespace ClearYearDaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearYearDaySchedule

				namespace SetHolidaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace SetHolidaySchedule

				namespace GetHolidaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace GetHolidaySchedule

				namespace GetHolidayScheduleResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetHolidayScheduleResponse

				namespace ClearHolidaySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearHolidaySchedule

				namespace SetUser
				{
					struct Type;
					struct DecodableType;
				} // namespace SetUser

				namespace GetUser
				{
					struct Type;
					struct DecodableType;
				} // namespace GetUser

				namespace GetUserResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetUserResponse

				namespace ClearUser
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearUser

				namespace SetCredential
				{
					struct Type;
					struct DecodableType;
				} // namespace SetCredential

				namespace SetCredentialResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace SetCredentialResponse

				namespace GetCredentialStatus
				{
					struct Type;
					struct DecodableType;
				} // namespace GetCredentialStatus

				namespace GetCredentialStatusResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetCredentialStatusResponse

				namespace ClearCredential
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearCredential

				namespace UnboltDoor
				{
					struct Type;
					struct DecodableType;
				} // namespace UnboltDoor

				namespace SetAliroReaderConfig
				{
					struct Type;
					struct DecodableType;
				} // namespace SetAliroReaderConfig

				namespace ClearAliroReaderConfig
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearAliroReaderConfig

			} // namespace Commands

			namespace Commands
			{
				namespace LockDoor
				{
					enum class Fields : uint8_t {
						kPINCode = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::LockDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::LockDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace LockDoor
				namespace UnlockDoor
				{
					enum class Fields : uint8_t {
						kPINCode = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnlockDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnlockDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace UnlockDoor
				namespace UnlockWithTimeout
				{
					enum class Fields : uint8_t {
						kTimeout = 0,
						kPINCode = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnlockWithTimeout::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint16_t timeout = static_cast<uint16_t>(0);
						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnlockWithTimeout::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t timeout = static_cast<uint16_t>(0);
						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace UnlockWithTimeout
				namespace SetWeekDaySchedule
				{
					enum class Fields : uint8_t {
						kWeekDayIndex = 0,
						kUserIndex = 1,
						kDaysMask = 2,
						kStartHour = 3,
						kStartMinute = 4,
						kEndHour = 5,
						kEndMinute = 6,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						chip::BitMask<DaysMaskMap> daysMask =
							static_cast<chip::BitMask<DaysMaskMap>>(0);
						uint8_t startHour = static_cast<uint8_t>(0);
						uint8_t startMinute = static_cast<uint8_t>(0);
						uint8_t endHour = static_cast<uint8_t>(0);
						uint8_t endMinute = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						chip::BitMask<DaysMaskMap> daysMask =
							static_cast<chip::BitMask<DaysMaskMap>>(0);
						uint8_t startHour = static_cast<uint8_t>(0);
						uint8_t startMinute = static_cast<uint8_t>(0);
						uint8_t endHour = static_cast<uint8_t>(0);
						uint8_t endMinute = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetWeekDaySchedule
				namespace GetWeekDaySchedule
				{
					enum class Fields : uint8_t {
						kWeekDayIndex = 0,
						kUserIndex = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::DoorLock::Commands::
							GetWeekDayScheduleResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetWeekDaySchedule
				namespace GetWeekDayScheduleResponse
				{
					enum class Fields : uint8_t {
						kWeekDayIndex = 0,
						kUserIndex = 1,
						kStatus = 2,
						kDaysMask = 3,
						kStartHour = 4,
						kStartMinute = 5,
						kEndHour = 6,
						kEndMinute = 7,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeekDayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<chip::BitMask<DaysMaskMap>> daysMask;
						Optional<uint8_t> startHour;
						Optional<uint8_t> startMinute;
						Optional<uint8_t> endHour;
						Optional<uint8_t> endMinute;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeekDayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<chip::BitMask<DaysMaskMap>> daysMask;
						Optional<uint8_t> startHour;
						Optional<uint8_t> startMinute;
						Optional<uint8_t> endHour;
						Optional<uint8_t> endMinute;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetWeekDayScheduleResponse
				namespace ClearWeekDaySchedule
				{
					enum class Fields : uint8_t {
						kWeekDayIndex = 0,
						kUserIndex = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearWeekDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t weekDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearWeekDaySchedule
				namespace SetYearDaySchedule
				{
					enum class Fields : uint8_t {
						kYearDayIndex = 0,
						kUserIndex = 1,
						kLocalStartTime = 2,
						kLocalEndTime = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						uint32_t localStartTime = static_cast<uint32_t>(0);
						uint32_t localEndTime = static_cast<uint32_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						uint32_t localStartTime = static_cast<uint32_t>(0);
						uint32_t localEndTime = static_cast<uint32_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetYearDaySchedule
				namespace GetYearDaySchedule
				{
					enum class Fields : uint8_t {
						kYearDayIndex = 0,
						kUserIndex = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::DoorLock::Commands::
							GetYearDayScheduleResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetYearDaySchedule
				namespace GetYearDayScheduleResponse
				{
					enum class Fields : uint8_t {
						kYearDayIndex = 0,
						kUserIndex = 1,
						kStatus = 2,
						kLocalStartTime = 3,
						kLocalEndTime = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetYearDayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<uint32_t> localStartTime;
						Optional<uint32_t> localEndTime;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetYearDayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<uint32_t> localStartTime;
						Optional<uint32_t> localEndTime;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetYearDayScheduleResponse
				namespace ClearYearDaySchedule
				{
					enum class Fields : uint8_t {
						kYearDayIndex = 0,
						kUserIndex = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearYearDaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t yearDayIndex = static_cast<uint8_t>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearYearDaySchedule
				namespace SetHolidaySchedule
				{
					enum class Fields : uint8_t {
						kHolidayIndex = 0,
						kLocalStartTime = 1,
						kLocalEndTime = 2,
						kOperatingMode = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t holidayIndex = static_cast<uint8_t>(0);
						uint32_t localStartTime = static_cast<uint32_t>(0);
						uint32_t localEndTime = static_cast<uint32_t>(0);
						OperatingModeEnum operatingMode = static_cast<OperatingModeEnum>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t holidayIndex = static_cast<uint8_t>(0);
						uint32_t localStartTime = static_cast<uint32_t>(0);
						uint32_t localEndTime = static_cast<uint32_t>(0);
						OperatingModeEnum operatingMode = static_cast<OperatingModeEnum>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetHolidaySchedule
				namespace GetHolidaySchedule
				{
					enum class Fields : uint8_t {
						kHolidayIndex = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t holidayIndex = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::DoorLock::Commands::
							GetHolidayScheduleResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t holidayIndex = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetHolidaySchedule
				namespace GetHolidayScheduleResponse
				{
					enum class Fields : uint8_t {
						kHolidayIndex = 0,
						kStatus = 1,
						kLocalStartTime = 2,
						kLocalEndTime = 3,
						kOperatingMode = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetHolidayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t holidayIndex = static_cast<uint8_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<uint32_t> localStartTime;
						Optional<uint32_t> localEndTime;
						Optional<OperatingModeEnum> operatingMode;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetHolidayScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t holidayIndex = static_cast<uint8_t>(0);
						DlStatus status = static_cast<DlStatus>(0);
						Optional<uint32_t> localStartTime;
						Optional<uint32_t> localEndTime;
						Optional<OperatingModeEnum> operatingMode;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetHolidayScheduleResponse
				namespace ClearHolidaySchedule
				{
					enum class Fields : uint8_t {
						kHolidayIndex = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint8_t holidayIndex = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearHolidaySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t holidayIndex = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearHolidaySchedule
				namespace SetUser
				{
					enum class Fields : uint8_t {
						kOperationType = 0,
						kUserIndex = 1,
						kUserName = 2,
						kUserUniqueID = 3,
						kUserStatus = 4,
						kUserType = 5,
						kCredentialRule = 6,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						DataOperationTypeEnum operationType =
							static_cast<DataOperationTypeEnum>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DataModel::Nullable<chip::CharSpan> userName;
						DataModel::Nullable<uint32_t> userUniqueID;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;
						DataModel::Nullable<CredentialRuleEnum> credentialRule;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataOperationTypeEnum operationType =
							static_cast<DataOperationTypeEnum>(0);
						uint16_t userIndex = static_cast<uint16_t>(0);
						DataModel::Nullable<chip::CharSpan> userName;
						DataModel::Nullable<uint32_t> userUniqueID;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;
						DataModel::Nullable<CredentialRuleEnum> credentialRule;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetUser
				namespace GetUser
				{
					enum class Fields : uint8_t {
						kUserIndex = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::DoorLock::Commands::GetUserResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetUser
				namespace GetUserResponse
				{
					enum class Fields : uint8_t {
						kUserIndex = 0,
						kUserName = 1,
						kUserUniqueID = 2,
						kUserStatus = 3,
						kUserType = 4,
						kCredentialRule = 5,
						kCredentials = 6,
						kCreatorFabricIndex = 7,
						kLastModifiedFabricIndex = 8,
						kNextUserIndex = 9,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetUserResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint16_t userIndex = static_cast<uint16_t>(0);
						DataModel::Nullable<chip::CharSpan> userName;
						DataModel::Nullable<uint32_t> userUniqueID;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;
						DataModel::Nullable<CredentialRuleEnum> credentialRule;
						DataModel::Nullable<
							DataModel::List<const Structs::CredentialStruct::Type>>
							credentials;
						DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
						DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
						DataModel::Nullable<uint16_t> nextUserIndex;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetUserResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint16_t userIndex = static_cast<uint16_t>(0);
						DataModel::Nullable<chip::CharSpan> userName;
						DataModel::Nullable<uint32_t> userUniqueID;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;
						DataModel::Nullable<CredentialRuleEnum> credentialRule;
						DataModel::Nullable<DataModel::DecodableList<
							Structs::CredentialStruct::DecodableType>>
							credentials;
						DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
						DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
						DataModel::Nullable<uint16_t> nextUserIndex;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetUserResponse
				namespace ClearUser
				{
					enum class Fields : uint8_t {
						kUserIndex = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearUser::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t userIndex = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearUser
				namespace SetCredential
				{
					enum class Fields : uint8_t {
						kOperationType = 0,
						kCredential = 1,
						kCredentialData = 2,
						kUserIndex = 3,
						kUserStatus = 4,
						kUserType = 5,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetCredential::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						DataOperationTypeEnum operationType =
							static_cast<DataOperationTypeEnum>(0);
						Structs::CredentialStruct::Type credential;
						chip::ByteSpan credentialData;
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::DoorLock::Commands::
							SetCredentialResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetCredential::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataOperationTypeEnum operationType =
							static_cast<DataOperationTypeEnum>(0);
						Structs::CredentialStruct::DecodableType credential;
						chip::ByteSpan credentialData;
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<UserStatusEnum> userStatus;
						DataModel::Nullable<UserTypeEnum> userType;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetCredential
				namespace SetCredentialResponse
				{
					enum class Fields : uint8_t {
						kStatus = 0,
						kUserIndex = 1,
						kNextCredentialIndex = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetCredentialResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						DlStatus status = static_cast<DlStatus>(0);
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<uint16_t> nextCredentialIndex;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetCredentialResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						DlStatus status = static_cast<DlStatus>(0);
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<uint16_t> nextCredentialIndex;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetCredentialResponse
				namespace GetCredentialStatus
				{
					enum class Fields : uint8_t {
						kCredential = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetCredentialStatus::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						Structs::CredentialStruct::Type credential;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::DoorLock::Commands::
							GetCredentialStatusResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetCredentialStatus::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Structs::CredentialStruct::DecodableType credential;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetCredentialStatus
				namespace GetCredentialStatusResponse
				{
					enum class Fields : uint8_t {
						kCredentialExists = 0,
						kUserIndex = 1,
						kCreatorFabricIndex = 2,
						kLastModifiedFabricIndex = 3,
						kNextCredentialIndex = 4,
						kCredentialData = 5,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetCredentialStatusResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						bool credentialExists = static_cast<bool>(0);
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
						DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
						DataModel::Nullable<uint16_t> nextCredentialIndex;
						Optional<DataModel::Nullable<chip::ByteSpan>> credentialData;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetCredentialStatusResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						bool credentialExists = static_cast<bool>(0);
						DataModel::Nullable<uint16_t> userIndex;
						DataModel::Nullable<chip::FabricIndex> creatorFabricIndex;
						DataModel::Nullable<chip::FabricIndex> lastModifiedFabricIndex;
						DataModel::Nullable<uint16_t> nextCredentialIndex;
						Optional<DataModel::Nullable<chip::ByteSpan>> credentialData;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetCredentialStatusResponse
				namespace ClearCredential
				{
					enum class Fields : uint8_t {
						kCredential = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearCredential::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						DataModel::Nullable<Structs::CredentialStruct::Type> credential;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearCredential::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::Nullable<Structs::CredentialStruct::DecodableType> credential;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearCredential
				namespace UnboltDoor
				{
					enum class Fields : uint8_t {
						kPINCode = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnboltDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::UnboltDoor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Optional<chip::ByteSpan> PINCode;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace UnboltDoor
				namespace SetAliroReaderConfig
				{
					enum class Fields : uint8_t {
						kSigningKey = 0,
						kVerificationKey = 1,
						kGroupIdentifier = 2,
						kGroupResolvingKey = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetAliroReaderConfig::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						chip::ByteSpan signingKey;
						chip::ByteSpan verificationKey;
						chip::ByteSpan groupIdentifier;
						Optional<chip::ByteSpan> groupResolvingKey;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetAliroReaderConfig::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::ByteSpan signingKey;
						chip::ByteSpan verificationKey;
						chip::ByteSpan groupIdentifier;
						Optional<chip::ByteSpan> groupResolvingKey;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetAliroReaderConfig
				namespace ClearAliroReaderConfig
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearAliroReaderConfig::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return true; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearAliroReaderConfig::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::DoorLock::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearAliroReaderConfig
			} // namespace Commands
		} // namespace DoorLock
	} // namespace Clusters
} // namespace app
} // namespace chip
